(function webpackUniversalModuleDefinition(root, factory) {
    if (typeof exports === 'object' && typeof module === 'object')
        module.exports = factory(require("katex"));
    else if (typeof define === 'function' && define.amd)
        define(["katex"], factory);
    else if (typeof exports === 'object')
        exports["renderMathInElement"] = factory(require("katex"));
    else
        root["renderMathInElement"] = factory(root["katex"]);
})((typeof self !== 'undefined' ? self : this), function (__WEBPACK_EXTERNAL_MODULE__0__) {
    return /******/ (function (modules) { // webpackBootstrap
        /******/ 	// The module cache
        /******/
        var installedModules = {};
        /******/
        /******/ 	// The require function
        /******/
        function __webpack_require__(moduleId) {
            /******/
            /******/ 		// Check if module is in cache
            /******/
            if (installedModules[moduleId]) {
                /******/
                return installedModules[moduleId].exports;
                /******/
            }
            /******/ 		// Create a new module (and put it into the cache)
            /******/
            var module = installedModules[moduleId] = {
                /******/            i: moduleId,
                /******/            l: false,
                /******/            exports: {}
                /******/
            };
            /******/
            /******/ 		// Execute the module function
            /******/
            modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
            /******/
            /******/ 		// Flag the module as loaded
            /******/
            module.l = true;
            /******/
            /******/ 		// Return the exports of the module
            /******/
            return module.exports;
            /******/
        }

        /******/
        /******/
        /******/ 	// expose the modules object (__webpack_modules__)
        /******/
        __webpack_require__.m = modules;
        /******/
        /******/ 	// expose the module cache
        /******/
        __webpack_require__.c = installedModules;
        /******/
        /******/ 	// define getter function for harmony exports
        /******/
        __webpack_require__.d = function (exports, name, getter) {
            /******/
            if (!__webpack_require__.o(exports, name)) {
                /******/
                Object.defineProperty(exports, name, {enumerable: true, get: getter});
                /******/
            }
            /******/
        };
        /******/
        /******/ 	// define __esModule on exports
        /******/
        __webpack_require__.r = function (exports) {
            /******/
            if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
                /******/
                Object.defineProperty(exports, Symbol.toStringTag, {value: 'Module'});
                /******/
            }
            /******/
            Object.defineProperty(exports, '__esModule', {value: true});
            /******/
        };
        /******/
        /******/ 	// create a fake namespace object
        /******/ 	// mode & 1: value is a module id, require it
        /******/ 	// mode & 2: merge all properties of value into the ns
        /******/ 	// mode & 4: return value when already ns object
        /******/ 	// mode & 8|1: behave like require
        /******/
        __webpack_require__.t = function (value, mode) {
            /******/
            if (mode & 1) value = __webpack_require__(value);
            /******/
            if (mode & 8) return value;
            /******/
            if ((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
            /******/
            var ns = Object.create(null);
            /******/
            __webpack_require__.r(ns);
            /******/
            Object.defineProperty(ns, 'default', {enumerable: true, value: value});
            /******/
            if (mode & 2 && typeof value != 'string') for (var key in value) __webpack_require__.d(ns, key, function (key) {
                return value[key];
            }.bind(null, key));
            /******/
            return ns;
            /******/
        };
        /******/
        /******/ 	// getDefaultExport function for compatibility with non-harmony modules
        /******/
        __webpack_require__.n = function (module) {
            /******/
            var getter = module && module.__esModule ?
                /******/            function getDefault() {
                    return module['default'];
                } :
                /******/            function getModuleExports() {
                    return module;
                };
            /******/
            __webpack_require__.d(getter, 'a', getter);
            /******/
            return getter;
            /******/
        };
        /******/
        /******/ 	// Object.prototype.hasOwnProperty.call
        /******/
        __webpack_require__.o = function (object, property) {
            return Object.prototype.hasOwnProperty.call(object, property);
        };
        /******/
        /******/ 	// __webpack_public_path__
        /******/
        __webpack_require__.p = "";
        /******/
        /******/
        /******/ 	// Load entry module and return exports
        /******/
        return __webpack_require__(__webpack_require__.s = 1);
        /******/
    })
        /************************************************************************/
        /******/ ([
            /* 0 */
            /***/ (function (module, exports) {

                module.exports = __WEBPACK_EXTERNAL_MODULE__0__;

                /***/
            }),
            /* 1 */
            /***/ (function (module, __webpack_exports__, __webpack_require__) {

                "use strict";
                __webpack_require__.r(__webpack_exports__);

// EXTERNAL MODULE: external "katex"
                var external_katex_ = __webpack_require__(0);
                var external_katex_default = /*#__PURE__*/__webpack_require__.n(external_katex_);

// CONCATENATED MODULE: ./contrib/auto-render/splitAtDelimiters.js
                /* eslint no-constant-condition:0 */
                var findEndOfMath = function findEndOfMath(delimiter, text, startIndex) {
                    // Adapted from
                    // https://github.com/Khan/perseus/blob/master/src/perseus-markdown.jsx
                    var index = startIndex;
                    var braceLevel = 0;
                    var delimLength = delimiter.length;

                    while (index < text.length) {
                        var character = text[index];

                        if (braceLevel <= 0 && text.slice(index, index + delimLength) === delimiter) {
                            return index;
                        } else if (character === "\\") {
                            index++;
                        } else if (character === "{") {
                            braceLevel++;
                        } else if (character === "}") {
                            braceLevel--;
                        }

                        index++;
                    }

                    return -1;
                };

                var splitAtDelimiters = function splitAtDelimiters(startData, leftDelim, rightDelim, display) {
                    var finalData = [];

                    for (var i = 0; i < startData.length; i++) {
                        if (startData[i].type === "text") {
                            var text = startData[i].data;
                            var lookingForLeft = true;
                            var currIndex = 0;
                            var nextIndex = void 0;
                            nextIndex = text.indexOf(leftDelim);

                            if (nextIndex !== -1) {
                                currIndex = nextIndex;
                                finalData.push({
                                    type: "text",
                                    data: text.slice(0, currIndex)
                                });
                                lookingForLeft = false;
                            }

                            while (true) {
                                if (lookingForLeft) {
                                    nextIndex = text.indexOf(leftDelim, currIndex);

                                    if (nextIndex === -1) {
                                        break;
                                    }

                                    finalData.push({
                                        type: "text",
                                        data: text.slice(currIndex, nextIndex)
                                    });
                                    currIndex = nextIndex;
                                } else {
                                    nextIndex = findEndOfMath(rightDelim, text, currIndex + leftDelim.length);

                                    if (nextIndex === -1) {
                                        break;
                                    }

                                    finalData.push({
                                        type: "math",
                                        data: text.slice(currIndex + leftDelim.length, nextIndex),
                                        rawData: text.slice(currIndex, nextIndex + rightDelim.length),
                                        display: display
                                    });
                                    currIndex = nextIndex + rightDelim.length;
                                }

                                lookingForLeft = !lookingForLeft;
                            }

                            finalData.push({
                                type: "text",
                                data: text.slice(currIndex)
                            });
                        } else {
                            finalData.push(startData[i]);
                        }
                    }

                    return finalData;
                };

                /* harmony default export */
                var auto_render_splitAtDelimiters = (splitAtDelimiters);
// CONCATENATED MODULE: ./contrib/auto-render/auto-render.js
                /* eslint no-console:0 */


                var auto_render_splitWithDelimiters = function splitWithDelimiters(text, delimiters) {
                    var data = [{
                        type: "text",
                        data: text
                    }];

                    for (var i = 0; i < delimiters.length; i++) {
                        var delimiter = delimiters[i];
                        data = auto_render_splitAtDelimiters(data, delimiter.left, delimiter.right, delimiter.display || false);
                    }

                    return data;
                };
                /* Note: optionsCopy is mutated by this method. If it is ever exposed in the
                 * API, we should copy it before mutating.
                 */


                var auto_render_renderMathInText = function renderMathInText(text, optionsCopy) {
                    var data = auto_render_splitWithDelimiters(text, optionsCopy.delimiters);
                    var fragment = document.createDocumentFragment();

                    for (var i = 0; i < data.length; i++) {
                        if (data[i].type === "text") {
                            fragment.appendChild(document.createTextNode(data[i].data));
                        } else {
                            var span = document.createElement("span");
                            var math = data[i].data; // Override any display mode defined in the settings with that
                            // defined by the text itself

                            optionsCopy.displayMode = data[i].display;

                            try {
                                if (optionsCopy.preProcess) {
                                    math = optionsCopy.preProcess(math);
                                }

                                external_katex_default.a.render(math, span, optionsCopy);
                            } catch (e) {
                                if (!(e instanceof external_katex_default.a.ParseError)) {
                                    throw e;
                                }

                                optionsCopy.errorCallback("KaTeX auto-render: Failed to parse `" + data[i].data + "` with ", e);
                                fragment.appendChild(document.createTextNode(data[i].rawData));
                                continue;
                            }

                            fragment.appendChild(span);
                        }
                    }

                    return fragment;
                };

                var renderElem = function renderElem(elem, optionsCopy) {
                    for (var i = 0; i < elem.childNodes.length; i++) {
                        var childNode = elem.childNodes[i];

                        if (childNode.nodeType === 3) {
                            // Text node
                            var frag = auto_render_renderMathInText(childNode.textContent, optionsCopy);
                            i += frag.childNodes.length - 1;
                            elem.replaceChild(frag, childNode);
                        } else if (childNode.nodeType === 1) {
                            (function () {
                                // Element node
                                var className = ' ' + childNode.className + ' ';
                                var shouldRender = optionsCopy.ignoredTags.indexOf(childNode.nodeName.toLowerCase()) === -1 && optionsCopy.ignoredClasses.every(function (x) {
                                    return className.indexOf(' ' + x + ' ') === -1;
                                });

                                if (shouldRender) {
                                    renderElem(childNode, optionsCopy);
                                }
                            })();
                        } // Otherwise, it's something else, and ignore it.

                    }
                };

                var renderMathInElement = function renderMathInElement(elem, options) {
                    if (!elem) {
                        throw new Error("No element provided to render");
                    }

                    var optionsCopy = {}; // Object.assign(optionsCopy, option)

                    for (var option in options) {
                        if (options.hasOwnProperty(option)) {
                            optionsCopy[option] = options[option];
                        }
                    } // default options


                    optionsCopy.delimiters = optionsCopy.delimiters || [{
                        left: "$$",
                        right: "$$",
                        display: true
                    }, {
                        left: "\\(",
                        right: "\\)",
                        display: false
                    }, // LaTeX uses $…$, but it ruins the display of normal `$` in text:
                        // {left: "$", right: "$", display: false},
                        //  \[…\] must come last in this array. Otherwise, renderMathInElement
                        //  will search for \[ before it searches for $$ or  \(
                        // That makes it susceptible to finding a \\[0.3em] row delimiter and
                        // treating it as if it were the start of a KaTeX math zone.
                        {
                            left: "\\[",
                            right: "\\]",
                            display: true
                        }];
                    optionsCopy.ignoredTags = optionsCopy.ignoredTags || ["script", "noscript", "style", "textarea", "pre", "code"];
                    optionsCopy.ignoredClasses = optionsCopy.ignoredClasses || [];
                    optionsCopy.errorCallback = optionsCopy.errorCallback || console.error; // Enable sharing of global macros defined via `\gdef` between different
                    // math elements within a single call to `renderMathInElement`.

                    optionsCopy.macros = optionsCopy.macros || {};
                    renderElem(elem, optionsCopy);
                };

                /* harmony default export */
                var auto_render = __webpack_exports__["default"] = (renderMathInElement);

                /***/
            })
            /******/])["default"];
});